home *** CD-ROM | disk | FTP | other *** search
/ Complete Linux / Complete Linux.iso / docs / system / manual_p / xinfo_1_.z / xinfo_1_ / Info.c < prev    next >
C/C++ Source or Header  |  1993-05-05  |  65KB  |  2,439 lines
  1. #ifndef lint
  2. static char *rcsid = "$Header: /usr3/xinfo/RCS/Info.c,v 1.9 91/01/07 14:01:06 jkh Exp Locker: jkh $";
  3. #endif
  4.  
  5. #include "InfoP.h"
  6.  
  7. #include <X11/Shell.h>
  8. #include <X11/StringDefs.h>
  9. #include <X11/Xaw/AsciiText.h>
  10. #include <X11/Xaw/Box.h>
  11. #include <X11/Xaw/Command.h>
  12. #include <X11/Xaw/Dialog.h>
  13. #include <X11/Xaw/Label.h>
  14. #include <X11/Xaw/List.h>
  15. #include <X11/Xaw/Paned.h>
  16. #include <X11/Xaw/Viewport.h>
  17.  
  18. #include <sys/stat.h>
  19. #include <stdio.h>
  20. #include <ctype.h>
  21. #include <pwd.h>
  22.  
  23. /*
  24.  *
  25.  *                   Copyright 1989, 1990
  26.  *                    Jordan K. Hubbard
  27.  *
  28.  *                PCS Computer Systeme, GmbH.
  29.  *                   Munich, West Germany
  30.  *
  31.  *
  32.  * This file is part of GNU Info widget.
  33.  *
  34.  * The GNU Info widget is free software; you can redistribute it and/or
  35.  * modify it under the terms of the GNU General Public License as published
  36.  * by the Free Software Foundation; either version 1, or (at your option)
  37.  * any later version.
  38.  *
  39.  * This software is distributed in the hope that it will be useful,
  40.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  41.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  42.  * GNU General Public License for more details.
  43.  *
  44.  * You should have received a copy of the GNU General Public License
  45.  * along with this software; see the file COPYING.  If not, write to
  46.  * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  47.  *
  48.  *
  49.  */
  50.  
  51. /*
  52.  * $Log:    Info.c,v $
  53.  * Revision 1.9  91/01/07  14:01:06  jkh
  54.  * Now handles compressed files, resource structure now properly declared
  55.  * (XtRInt -> XtRImmediate where appropriate). Node name saved for goto
  56.  * attempts.
  57.  * 
  58.  * Revision 1.8  90/11/12  18:06:46  jkh
  59.  * Removed aggregate initializations. GCC likes them, noone else does.
  60.  * 
  61.  * Revision 1.7  90/11/12  13:46:11  jkh
  62.  * Fixed bug with bell_volume resource
  63.  * 
  64.  * Revision 1.6  90/11/11  23:22:59  jkh
  65.  * Last minute fixes.
  66.  * 
  67.  * Revision 1.5  90/11/11  22:24:05  jkh
  68.  * Added option to enable/disable retention of arg text.
  69.  * 
  70.  * Revision 1.4  90/11/11  21:19:39  jkh
  71.  * Release 1.01
  72.  * 
  73.  * Revision 1.3  90/11/07  01:28:30  jkh
  74.  * Tweaked dialog popup to accept <return> as fast confirm.
  75.  * 
  76.  * Revision 1.2  90/11/06  15:12:47  jkh
  77.  * Fixed memory leaks
  78.  * 
  79.  * Revision 1.1  90/11/06  01:47:28  jkh
  80.  * Initial revision
  81.  * 
  82.  */
  83.  
  84. #define offset(name)    XtOffset(InfoWidget, info.name)
  85. #define CDT(name)    (XtPointer)(name)
  86.  
  87. Local XtResource resources[] = {
  88.      { XpNinfoPath, XpCInfoPath, XtRString, sizeof(String),
  89.         offset(path), XtRString, CDT(XpDefaultInfoPath)        },
  90.      { XpNinfoFile, XpCInfoFile, XtRString, sizeof(String),
  91.         offset(file), XtRString, CDT(XpDefaultInfoFile)        },
  92.      { XpNinfoNode, XpCInfoNode, XtRString, sizeof(String),
  93.         offset(node), XtRString, CDT(XpDefaultInfoNode)        },
  94.      { XpNbellVolume, XpCBellVolume, XtRInt, sizeof(int),
  95.         offset(bell_volume), XtRImmediate, CDT(XpDefaultBellVolume)    },
  96.      { XpNretainArg, XpCRetainArg, XtRBoolean, sizeof(Boolean),
  97.         offset(retain_arg), XtRImmediate, CDT(False)        },
  98.      { XpNprintCommand, XpCPrintCommand, XtRString, sizeof(String),
  99.         offset(printCmd), XtRString, CDT(XpDefaultPrintCommand)    },
  100.      { XtNcallback, XtCCallback, XtRCallback, sizeof(caddr_t),
  101.         offset(callback), XtRCallback, CDT(NULL)            },
  102. };
  103.  
  104. #undef offset
  105. #undef CDT
  106.  
  107. Local Boolean SetValues();
  108. Local XtGeometryResult GeometryManager();
  109. Local void Destroy();
  110. Local void Initialize();
  111. Local void Realize();
  112. Local void Resize();
  113.  
  114. /* Routines called directly by actions */
  115. Local void Abort();
  116. Local void ButtonSelection();
  117. Local void Confirm();
  118. Local void NodeDir();
  119. Local void NodeGoto();
  120. Local void NodeHelp();
  121. Local void NodeLast();
  122. Local void NodeMenuSelectByNumber();
  123. Local void NodeNext();
  124. Local void NodePrev();
  125. Local void NodePrint();
  126. Local void NodeQuit();
  127. Local void NodeSearch();
  128. Local void NodeTop();
  129. Local void NodeTutorial();
  130. Local void NodeUp();
  131. Local void NodeXRef();
  132.  
  133. /* Routines called directly from callbacks or indirectly by actions */
  134. Local void do_dialog_abort();
  135. Local void do_dialog_confirm();
  136. Local void do_goto();
  137. Local void do_menu();
  138. Local void do_menu_sel();
  139. Local void do_next();
  140. Local void do_popdown();
  141. Local void do_prev();
  142. Local void do_quit();
  143. Local void do_search();
  144. Local void do_up();
  145. Local void do_xref();
  146. Local void do_xref_sel();
  147.  
  148. /* Utility routines */
  149. Local Boolean getNode();
  150. Local Boolean parseTags();
  151. Local InfoWidget find_top();
  152. Local NodeInfo *popNode();
  153. Local NodeInfo *pushNode();
  154. Local String downcase();
  155. Local String eat_whitespace();
  156. Local String file_name();
  157. Local String find_file();
  158. Local String getFile();
  159. Local String get_arg();
  160. Local String normalize_whitespace();
  161. Local String offsetToString();
  162. Local String reverse();
  163. Local String search();
  164. Local String search_back();
  165. Local String strconcat();
  166. Local String substr();
  167. Local String trueName();
  168. Local int findNode();
  169. Local int iindex();
  170. Local int strcomp();
  171. Local int strncomp();
  172. Local void clear_arg();
  173. Local void dialog();
  174. Local void displayHeader();
  175. Local void displayNode();
  176. Local void feep();
  177. Local void getXY();
  178. Local void message();
  179. Local void parseHeader();
  180. Local void parseIndirect();
  181. Local void parseMenu();
  182. Local void parseNode();
  183. Local void parseXRefs();
  184. Local void showStatus();
  185. Local void strccpy();
  186.  
  187. Local XtActionsRec actionTable[] =
  188. {
  189.      {    "abort",        Abort            },
  190.      {    "confirm",        Confirm            },
  191.      {    "info_click",        ButtonSelection        },
  192.      {    "info_dir",        NodeDir            },
  193.      {    "info_goto",        NodeGoto        },
  194.      {    "info_last",        NodeLast        },
  195.      {    "info_menusel",        NodeMenuSelectByNumber    },
  196.      {    "info_next",        NodeNext        },
  197.      {    "info_nodeSearch",    NodeSearch        },
  198.      {    "info_popupHelp",    NodeHelp        },
  199.      {    "info_prev",        NodePrev        },
  200.      {    "info_print",        NodePrint        },
  201.      {    "info_quit",        NodeQuit        },
  202.      {    "info_top",        NodeTop            },
  203.      {    "info_tutorial",    NodeTutorial        },
  204.      {    "info_up",        NodeUp            },
  205.      {    "info_xref",        NodeXRef        },
  206.      {    NULL,            NULL            }
  207. };
  208.  
  209. Export InfoClassRec infoClassRec = {
  210.      {    /* core fields */
  211.     /* superclass        */    (WidgetClass)&compositeClassRec,
  212.     /* class_name        */    "Info",
  213.     /* widget_size        */    sizeof(InfoRec),
  214.     /* class_initialize    */    NULL,
  215.     /* class_part_initialize*/    NULL,
  216.     /* class_inited        */    FALSE,
  217.     /* initialize        */    Initialize,
  218.     /* initialize_hook    */    NULL,
  219.     /* realize        */    Realize,
  220.     /* actions        */    actionTable,
  221.     /* num_actions        */    XtNumber(actionTable),
  222.     /* resources        */    resources,
  223.     /* num_resources    */    XtNumber(resources),
  224.     /* xrm_class        */    NULLQUARK,
  225.     /* compress_motion    */    TRUE,
  226.     /* compress_exposure    */    TRUE,
  227.     /* compress_enterleave    */    TRUE,
  228.     /* visible_interest    */    FALSE,
  229.     /* destroy        */    Destroy,
  230.     /* resize        */    Resize,
  231.     /* expose        */    XtInheritExpose,
  232.     /* set_values        */    SetValues,
  233.     /* set_values_hook    */    NULL,
  234.     /* set_values_almost    */    XtInheritSetValuesAlmost,
  235.     /* get_values_hook    */    NULL,
  236.     /* accept_focus        */    XtInheritAcceptFocus,
  237.     /* version        */    XtVersion,
  238.     /* callback_private    */    NULL,
  239.     /* tm_table        */    NULL,
  240.     /* query_geometry    */    XtInheritQueryGeometry,
  241.     /* display_accelerator    */    XtInheritDisplayAccelerator,
  242.     /* extension        */    NULL
  243.      },
  244.      {    /* composite fields    */
  245.     /* geometry_manager    */    GeometryManager,
  246.     /* change_managed    */    NULL,
  247.     /* insert_child        */    XtInheritInsertChild,
  248.     /* delete_child        */    XtInheritDeleteChild,
  249.     /* extension        */    NULL,
  250.      },
  251.      { /* info fields        */
  252.     /* empty        */    0
  253.      }
  254. };
  255.  
  256. Export WidgetClass infoWidgetClass = (WidgetClass)&infoClassRec;
  257.  
  258. #ifndef tolower
  259. #include <X11/Xos.h>
  260. #define TOLOWER(c) (tolower(c))
  261. #else
  262. #define TOLOWER(c) (isupper(c) ? tolower(c) : (c))
  263. #endif
  264.  
  265. Local XtCallbackRec cb[2];
  266. #define XtSetCbk(argarray, rtn, arg) \
  267.      cb[0].callback = rtn; \
  268.      cb[0].closure = (caddr_t)arg; \
  269.      XtSetArg(argarray, XtNcallback, cb)
  270.  
  271. /*****************************************************************************
  272.  * Widget manipulation routines.                                             *
  273.  *****************************************************************************/
  274.  
  275. Local Boolean SetValues(current, request, new)
  276. Widget current, request, new;
  277. {
  278.      InfoWidget cw = (InfoWidget)current;
  279.      InfoWidget nw = (InfoWidget)new;
  280.      
  281.      if (cw->info.file != nw->info.file
  282.      || strcomp(cw->info.file, nw->info.file)
  283.      || cw->info.node != nw->info.node
  284.      || strcomp(cw->info.node, nw->info.node)) {
  285.       XtFree(cw->info.file);
  286.       XtFree(cw->info.node);
  287.       getNode(nw, nw->info.file, nw->info.node, NULL);
  288.      }
  289.      /* getNode() does the redisplay implicitly */
  290.      return FALSE;
  291. }
  292.  
  293. /* We only manage one widget (the pane) directly */
  294. Local XtGeometryResult GeometryManager(w, request, reply)
  295. InfoWidget w;
  296. XtWidgetGeometry *request;
  297. XtWidgetGeometry *reply; /* RETURN */
  298. {
  299.      XtGeometryResult res;
  300.      Dimension width, height;
  301.      
  302.      width = w->core.width;
  303.      height = w->core.height;
  304.      
  305.      /* We don't really care; see what daddy says */
  306.      res = XtMakeGeometryRequest(XtParent(w), request, reply);
  307.      if (res == XtGeometryNo)
  308.       return res;
  309.      else if (res == XtGeometryAlmost) {
  310.       if (reply->request_mode & CWWidth)
  311.            width = reply->width;
  312.       if (reply->request_mode & CWHeight)
  313.            height = reply->height;
  314.      }
  315.      else { /* Has to be XtGeometryYes */
  316.       if (request->request_mode & CWWidth)
  317.            width = request->width;
  318.       if (request->request_mode & CWHeight)
  319.            height = request->height;
  320.      }
  321.      XtResizeWidget(w, width, height, w->core.border_width);
  322. }
  323.  
  324. Local void Destroy(w)
  325. Widget w;
  326. {
  327.      InfoWidget iw = (InfoWidget)w;
  328.      
  329.      if (INDIRECT(iw).table)
  330.       FREE_TAG_TABLE(INDIRECT(iw));
  331.      if (TAGTABLE(iw).table)
  332.       FREE_TAG_TABLE(TAGTABLE(iw));
  333.      while (popNode(iw));    /* popNode will free all but last */
  334.      /* now free the last one */
  335.      if (CURNODE(iw)) {
  336.       XtFree(CURNODE(iw)->file);
  337.       XtFree(CURNODE(iw)->node);
  338.       FREE_LIST(CURNODE(iw)->menu);
  339.       FREE_LIST(CURNODE(iw)->xref);
  340.       XtFree(CURNODE(iw));
  341.      }
  342.      if (DATA(iw))
  343.       XtFree(DATA(iw));
  344.      XtFree(iw->info.file);
  345.      XtFree(iw->info.node);
  346. }
  347.  
  348. Local void Initialize(request, new)
  349. Widget request;
  350. Widget new;
  351. {
  352.      Arg args[15];
  353.      Cardinal i;
  354.      InfoWidget iw = (InfoWidget)new;
  355.      Widget top, box1, box2, vport, vport2;
  356.      char blanks[MAXSTR], *cp;
  357.      Import char *bzero();
  358.      
  359.      /* create a blank filled string as a placeholder for certain labels */
  360.      for (i = 0; i < MAXSTR - 1; i++)
  361.       blanks[i] = ' ';
  362.      blanks[i] = '\0';
  363.      
  364.      /* Pick some desperation defaults */
  365.      if (new->core.width == 0)
  366.       new->core.width = 100;
  367.      if (new->core.height == 0)
  368.       new->core.height = 50;
  369.      
  370.      /* Prevent later confusion */
  371.      iw->info.arg[0] = '\0';
  372.      
  373.      /* Create outer pane */
  374.      i = 0;
  375.      top = XtCreateManagedWidget("pane1", panedWidgetClass, new, args, i);
  376.      
  377.      /* Create top row of "main control" buttons and labels. */
  378.      i = 0;
  379.      box1 = XtCreateManagedWidget("box1", boxWidgetClass, top, args, i);
  380.      
  381.      if (iw->info.callback) {
  382.       Widget q;
  383.       
  384.       i = 0;
  385.       q = XtCreateManagedWidget("quit", commandWidgetClass,
  386.                     box1, args, i);
  387.       XtAddCallback(q, XtNcallback, do_quit, iw);
  388.      }
  389.      i = 0;
  390.      XtSetArg(args[i], XtNlabel, "File: ");                i++;
  391.      iw->info.fileLabel = XtCreateManagedWidget("file", labelWidgetClass,
  392.                         box1, args, i);
  393.      i = 0;
  394.      XtSetArg(args[i], XtNlabel, "Node: ");                i++;
  395.      iw->info.nodeLabel = XtCreateManagedWidget("node", labelWidgetClass,
  396.                         box1, args, i);
  397.      i = 0;
  398.      XtSetArg(args[i], XtNlabel, "Prev: ");                i++;
  399.      XtSetCbk(args[i], do_prev, iw);                    i++;
  400.      iw->info.prevCmd = XtCreateManagedWidget("prev", commandWidgetClass,
  401.                           box1, args, i);
  402.      i = 0;
  403.      XtSetArg(args[i], XtNlabel, "Up: ");                i++;
  404.      XtSetCbk(args[i], do_up, iw);                    i++;
  405.      iw->info.upCmd = XtCreateManagedWidget("up", commandWidgetClass,
  406.                         box1, args, i);
  407.      i = 0;
  408.      XtSetArg(args[i], XtNlabel, "Next: ");                i++;
  409.      XtSetCbk(args[i], do_next, iw);                    i++;
  410.      iw->info.nextCmd = XtCreateManagedWidget("next", commandWidgetClass,
  411.                           box1, args, i);
  412.      
  413.      /* Create the menu pane */
  414.      i = 0;
  415.      XtSetArg(args[i], XtNallowVert, TRUE);                i++;
  416.      vport = XtCreateManagedWidget("vport1", viewportWidgetClass,
  417.                    top, args, i);
  418.      
  419.      i = 0;
  420.      XtSetCbk(args[i], do_menu_sel, iw);                i++;
  421.      iw->info.menuList = XtCreateManagedWidget("menu", listWidgetClass,
  422.                            vport, args, i);
  423.      /*
  424.       * Create the text area for displaying node contents.
  425.       */
  426.      i = 0;
  427.      XtSetArg(args[i], XtNstring, blanks);                i++;
  428.      XtSetArg(args[i], XtNlength, MAXSTR);                i++;
  429.      XtSetArg(args[i], XtNeditType, XawtextRead);            i++;
  430.      XtSetArg(args[i], XtNuseStringInPlace, TRUE);            i++;
  431.      XtSetArg(args[i], XtNtype, XawAsciiString);            i++;
  432.      iw->info.nodeText = XtCreateManagedWidget("nodeText",
  433.                            asciiTextWidgetClass,
  434.                            top, args, i);
  435.      i = 0;
  436.      XtSetArg(args[i], XtNallowVert, TRUE);                i++;
  437.      vport2 = XtCreateManagedWidget("vport2", viewportWidgetClass,
  438.                     top, args, i);
  439.      
  440.      /* Create the xref pane */
  441.      i = 0;
  442.      XtSetCbk(args[i], do_xref_sel, iw);                i++;
  443.      iw->info.xrefList = XtCreateManagedWidget("xref", listWidgetClass,
  444.                            vport2, args, i);
  445.      
  446.      /*
  447.       * Create the bottom "auxilliary" command button group.
  448.       */
  449.      i = 0;
  450.      box2 = XtCreateManagedWidget("box2", boxWidgetClass,
  451.                   top, args, i);
  452.      i = 0;
  453.      XtSetCbk(args[i], do_menu, iw);                    i++;
  454.      iw->info.xrefCmd = XtCreateManagedWidget("menu", commandWidgetClass,
  455.                           box2, args, i);
  456.      i = 0;
  457.      XtSetCbk(args[i], do_xref, iw);                    i++;
  458.      iw->info.xrefCmd = XtCreateManagedWidget("xref", commandWidgetClass,
  459.                           box2, args, i);
  460.      i = 0;
  461.      XtSetCbk(args[i], do_goto, iw);                    i++;
  462.      iw->info.gotoCmd = XtCreateManagedWidget("goto", commandWidgetClass,
  463.                           box2, args, i);
  464.      i = 0;
  465.      XtSetCbk(args[i], do_search, iw);                    i++;
  466.      iw->info.searchCmd = XtCreateManagedWidget("search", commandWidgetClass,
  467.                         box2, args, i);
  468.      i = 0;
  469.      bzero(iw->info.arg, ARGLEN);
  470.      XtSetArg(args[i], XtNstring, iw->info.arg);            i++;
  471.      XtSetArg(args[i], XtNlength, ARGLEN);                i++;
  472.      XtSetArg(args[i], XtNuseStringInPlace, TRUE);            i++;
  473.      XtSetArg(args[i], XtNeditType, XawtextEdit);            i++;
  474.      iw->info.argText = XtCreateManagedWidget("arg", asciiTextWidgetClass,
  475.                           box2, args, i);
  476.      
  477.      /*
  478.       * Create the status and message area labels.
  479.       */
  480.      i = 0;
  481.      XtSetArg(args[i], XtNresize, FALSE);                i++;
  482.      XtSetArg(args[i], XtNlabel, blanks);                i++;
  483.      XtSetArg(args[i], XtNborderWidth, 0);                i++;
  484.      iw->info.statusLabel = XtCreateManagedWidget("status", labelWidgetClass,
  485.                           top, args, i);
  486.      i = 0;
  487.      XtSetArg(args[i], XtNresize, FALSE);                i++;
  488.      XtSetArg(args[i], XtNlabel, blanks);                i++;
  489.      XtSetArg(args[i], XtNborderWidth, 0);                i++;
  490.      iw->info.messageLabel = XtCreateManagedWidget("message", labelWidgetClass,
  491.                            top, args, i);
  492.      
  493.      /* set the initial node information */
  494.      ZERO_TABLE(INDIRECT(iw));
  495.      ZERO_TABLE(TAGTABLE(iw));
  496.      DATA(iw) = NULL;
  497.      CURNODE(iw) = NULL;
  498.      
  499.      iw->info.file = XtNewString(iw->info.file);
  500.      iw->info.node = XtNewString(iw->info.node);
  501.      
  502.      if (getNode(iw, iw->info.file, iw->info.node, NULL) == FALSE)
  503.       message(iw, "?Can't find initial file/node.");
  504. }
  505.  
  506. Local void Realize(w, value_mask, attributes)
  507. InfoWidget w;
  508. Mask *value_mask;
  509. XSetWindowAttributes *attributes;
  510. {
  511.      if (w->composite.num_children < 1)
  512.       XtError("No children?!?");
  513.      else {
  514.       /* Create window with which to manage child */
  515.       XtCreateWindow(w, (unsigned int)InputOutput,
  516.              (Visual *)CopyFromParent, *value_mask, attributes);
  517.       XtResizeWidget(w->composite.children[0], w->core.width,
  518.              w->core.height, 0);
  519.       /*
  520.        * Install accelerators onto widgets we know will need them.
  521.        * Note that Volume 4 of the O'Reilly "X Toolkit Intrinsics
  522.        * Programming Manual" (page 204, paragraph 5) says that widgets
  523.        * should never do this. I disagree: here's a case in point.
  524.        */
  525.       XtInstallAllAccelerators(w, w);
  526.       XtInstallAccelerators(w->info.nodeText, w);
  527.      }
  528. }
  529.  
  530. Local void Resize(w)
  531. InfoWidget w;
  532. {
  533.      XtResizeWidget(w->composite.children[0], w->core.width, w->core.height,
  534.             0);
  535. }
  536.  
  537. /*****************************************************************************
  538.  * Info file manipulation routines.                                          *
  539.  *****************************************************************************/
  540.  
  541. /* Here is the main guy. Handles all navigation within the info tree. */
  542. Local Boolean getNode(iw, file, node, pushTo)
  543. InfoWidget iw;
  544. String file, node;
  545. NodeInfo *pushTo;
  546. {
  547.      NodeInfo *cur;
  548.      int offset;
  549.      Boolean status = FALSE, needfile;
  550.      
  551.      if (node && index(node, '(') && index(node, ')')) {
  552.       file = substr(node, iindex(node, '(') + 1,
  553.             iindex(node, ')') - 1);
  554.       node = index(node, ')') + 1;
  555.      }
  556.      if (!node || !*node)
  557.       node = "Top";
  558.      
  559.      if (!file) {
  560.       file = iw->info.file;
  561.       needfile = !DATA(iw);
  562.      }
  563.      else
  564.       needfile = !DATA(iw) ||
  565.            strcomp(file_name(file), file_name(iw->info.file));
  566.      if (needfile) {
  567.       /* get a new file */
  568.       if ((file = getFile(iw, file, FALSE)) != NULL) {
  569.            if (file && iw->info.file != file) {
  570.             XtFree(iw->info.file);
  571.             iw->info.file = XtNewString(file);
  572.            }
  573.            iw->info.subFile = NULL;
  574.       }
  575.      }
  576.      else if (!strcomp(node, iw->info.node))
  577.       return TRUE;    /* we're already there */
  578.      else {
  579.       XtFree(iw->info.node);
  580.       iw->info.node = XtNewString(node);
  581.      }
  582.      if (file && (offset = findNode(iw, node)) >= 0) {
  583.       if (!pushTo) {
  584.            cur = pushNode(iw, iw->info.file, iw->info.node, offset);
  585.            parseNode(iw, cur, offset);
  586.       }
  587.       else
  588.            cur = pushTo;
  589.       displayNode(iw, cur);
  590.       message(iw, NULL);
  591.       showStatus(iw, cur);
  592.       if (!iw->info.retain_arg)
  593.            clear_arg(iw);
  594.       status = TRUE;
  595.      }
  596.      else {
  597.       /* Failed to get the new node, go back (but only once) */
  598.       if (!pushTo && CURNODE(iw))
  599.            getNode(iw, CURNODE(iw)->file, CURNODE(iw)->node, CURNODE(iw));
  600.      }
  601.      return status;
  602. }
  603.  
  604. #ifdef    UNCOMPRESS
  605.  
  606. Local Inline int iscompressed(fname)
  607. String fname;
  608. {
  609.      int len = strlen(fname);
  610.      
  611.      return len >= 2 && (!strcmp(".Z", fname + len - 2) || 
  612.              !strcmp(".z", fname + len - 2));
  613. }
  614.  
  615. Local FILE* iopen(fname, dir)
  616. String fname;
  617. String dir;
  618. {
  619.      int len = strlen(fname);
  620.      
  621.      if (iscompressed(fname)) {
  622.       /* This is a compressed file. */
  623.       char cmd[MAXPATHLEN + sizeof(UNCOMPRESS) + 1];
  624.       
  625.       sprintf(cmd, "%s < %s", UNCOMPRESS, fname);
  626.       return popen(cmd, dir);
  627.      }
  628.      else
  629.       return fopen(fname, dir);
  630. }
  631.  
  632. #else    /* !UNCOMPRESS */
  633.  
  634. #define iscompressed(fname)    (0)
  635. #define iopen(fname, dir)    fopen(fname, dir)
  636.  
  637. #endif    /* UNCOMPRESS */
  638.  
  639. /* Loads in file "name" and tag/indirect info, if any. */
  640. Local String getFile(iw, name, subfilep)
  641. InfoWidget iw;
  642. String name;
  643. Boolean subfilep;
  644. {
  645.      String ret;
  646.      
  647.      FILE *fp;
  648.      
  649.      ret = find_file(iw->info.path, name);
  650.      if (ret) {
  651.       Import int stat();
  652.       struct stat sb;
  653.  
  654.       if (!stat(ret, &sb) && (fp = iopen(ret, "r"))) {
  655.            int expected, total;
  656.            Boolean compressed = iscompressed(ret);
  657.  
  658.            if (DATA(iw)) {
  659.             XtFree(DATA(iw));
  660.             DATA(iw) = NULL;
  661.            }
  662.            /*
  663.         * If the file is compressed, we make a worst-case guess
  664.         * (though space-wise it's certainly the BEST case) that 
  665.         * the uncompressed data will be 4 times larger than the
  666.         * original file. This is REALLY KLUDGE but there's really
  667.         * not much else to do, short of uncompressing to a temp file
  668.         * which is even less reliable (what if you haven't got enough
  669.         * tmp space?). Oh well. We do realloc it later, once we know
  670.         * how much was really read.
  671.         */
  672.            expected = compressed ? 4 * sb.st_size : sb.st_size;
  673.            DATA(iw) = XtMalloc(expected + 1);
  674.            if (compressed) {
  675.             int left;
  676.             char *next;
  677.             
  678.             next = DATA(iw);
  679.             left = expected;
  680.             while (left >= 0) {
  681.              int nread;
  682.              extern int errno;
  683.             
  684.              errno = 0;
  685.              nread = fread(next, 1, left, fp);
  686.              if (nread > 0) {
  687.                   next += nread;
  688.                   left -= nread;
  689.              }
  690.              else if (errno) {
  691.                   message(iw, "?Read error on pipe for %s.", name);
  692.                   pclose(fp);
  693.                   fp = NULL;
  694.                   XtFree(DATA(iw));
  695.                   ret = NULL;
  696.                   break;
  697.              }
  698.              else {
  699.                   pclose(fp);
  700.                   fp = NULL;
  701.                   total = next - DATA(iw);
  702.                   break;
  703.              }
  704.             }
  705.             if (fp) {
  706.              message(iw, "?Underestimated expansion of %s.", ret);
  707.              pclose(fp);
  708.              fp = NULL;
  709.              XtFree(DATA(iw));
  710.              ret = NULL;
  711.             }
  712.             else /* reclaim excess space */
  713.              DATA(iw) = XtRealloc(DATA(iw), total + 1);
  714.            }
  715.            else {
  716.             /* Not compressed, just slurp it in */
  717.             if (fread(DATA(iw), 1, sb.st_size, fp) == sb.st_size) {
  718.              fclose(fp);
  719.              total = sb.st_size;
  720.             }
  721.             else {
  722.              message(iw, "?Read error on %s.", name);
  723.              fclose(fp);
  724.              XtFree(DATA(iw));
  725.              ret = NULL;
  726.             }
  727.            }
  728.            if (ret) {
  729.             DATA(iw)[DATASIZE(iw) = total] = '\0';
  730.             if (!subfilep) {
  731.              Boolean needIndirect;
  732.              needIndirect = parseTags(iw);
  733.              parseIndirect(iw, needIndirect);
  734.             }
  735.            }
  736.       }
  737.       else
  738.            ret = NULL;
  739.      }
  740.      return ret;
  741. }
  742.  
  743. /* Look through tag table (and/or current buffer) for a node */
  744. Local int findNode(iw, name)
  745. InfoWidget iw;
  746. String name;
  747. {
  748.      ID_P i;
  749.      int offset = -1;
  750.      String s, srch;
  751.      
  752.      /* A node name of "*" means the whole file */
  753.      if (!strcomp(name, "*"))
  754.       return 0;
  755.      
  756.      if (TAGTABLE(iw).table) {
  757.       for (i = TAGTABLE(iw).table; I_NAME(*i); i++) {
  758.            if (!strcomp(I_NAME(*i), name)) {
  759.             offset = I_OFFSET(*i);
  760.             break;
  761.            }
  762.       }
  763.       /* if we found the tag and there's an indirect table, adjust */
  764.       if (offset > 0 && INDIRECT(iw).table) {
  765.            String sub;
  766.            
  767.            for (i = INDIRECT(iw).table; I_NAME(*i); i++) {
  768.             if (I_OFFSET(*i) > offset)    /* got it */
  769.              break;
  770.            }
  771.            sub = I_NAME(*(--i));
  772.            if (strcomp(sub, iw->info.subFile)) {
  773.             if (!getFile(iw, sub, TRUE))
  774.              return 0;
  775.             else
  776.              iw->info.subFile = sub;
  777.            }
  778.            offset -= I_OFFSET(*i);
  779.            /* compensate for header */
  780.            offset += HDRSIZE(iw);
  781.       }
  782.      }
  783.      /*
  784.       * Now search forward for the node name. Note that this will
  785.       * work whether or not we found the tag in the tag table. Having
  786.       * found the tag only insures that we search a little less.
  787.       */
  788.      s = START(iw);
  789.      if (offset > 0)
  790.       s += offset;
  791.      
  792.      /*
  793.       * since bogus tags can leave us *after* the node start as well as
  794.       * before it, we risk a little extra searching and back up to the
  795.       * closest node marker above. Es tut mir leid, but this is what you
  796.       * get with out-of-date tags!
  797.       */
  798.      while (s > START(iw) && !INFO_CHAR(*s))
  799.       --s;
  800.      srch = strconcat(NODE_TOKEN, name);
  801.      while (s) {
  802.       if ((s = search(iw, s, END(iw), srch, TRUE)) != NULL) {
  803.            /* If not an exact match, keep looking */
  804.            if (!index(NAME, *s))
  805.             continue;
  806.            offset = INTOFF(START(iw), s);
  807.            /* found it, move to the beginning */ 
  808.            while(!INFO_CHAR(START(iw)[offset - 1]))
  809.             offset--;
  810.            s = NULL;
  811.       }
  812.       else
  813.            offset = -1;
  814.      }
  815.      return offset;
  816. }
  817.  
  818. /* Push a node onto the history list */
  819. Local NodeInfo *pushNode(iw, file, node, offset)
  820. InfoWidget iw;
  821. String file, node;
  822. int offset;
  823. {
  824.      NodeInfo *tmp;
  825.      
  826.      tmp = XtNew(NodeInfo);
  827.      bzero(tmp, sizeof(NodeInfo));
  828.      tmp->file = XtNewString(file);
  829.      tmp->node = XtNewString(node);
  830.      tmp->start = offset;
  831.      tmp->nextNode = CURNODE(iw);
  832.      CURNODE(iw) = tmp;
  833.      return tmp;
  834. }
  835.  
  836. /* Pop a node off the history list */
  837. Local NodeInfo *popNode(iw)
  838. InfoWidget iw;
  839. {
  840.      NodeInfo *tmp = NULL;
  841.      
  842.      if (CURNODE(iw) && CURNODE(iw)->nextNode) {
  843.       tmp = CURNODE(iw)->nextNode;
  844.       XtFree(CURNODE(iw)->file);
  845.       XtFree(CURNODE(iw)->node);
  846.       FREE_LIST(CURNODE(iw)->menu);
  847.       FREE_LIST(CURNODE(iw)->xref);
  848.       XtFree(CURNODE(iw));
  849.       CURNODE(iw) = tmp;
  850.      }
  851.      return tmp;
  852. }
  853.  
  854. /* Parse out all the header/menu/xref information for a node. */
  855. Local void parseNode(iw, n, offset)
  856. InfoWidget iw;
  857. NodeInfo *n;
  858. int offset;
  859. {
  860.      register String start = START(iw) + offset;
  861.      
  862.      /* was the whole file ("*") selected? */
  863.      if (offset == 0) {
  864.       n->length = DATASIZE(iw);
  865.       I_START(n->name) = I_LEN(n->name) = 0;
  866.       I_START(n->prev) = I_LEN(n->prev) = 0;
  867.       I_START(n->up) = I_LEN(n->up) = 0;
  868.       I_START(n->next) = I_LEN(n->next) = 0;
  869.       I_START(n->text) = 0;
  870.       I_LEN(n->text) = n->length;
  871.      }
  872.      else {
  873.       /* find the end of the node */
  874.       n->length = 0;
  875.       start = START(iw) + offset;
  876.       while (start < END(iw) && !INFO_CHAR(*start)) {
  877.            n->length++;
  878.            start++;
  879.       }
  880.      }
  881.      /* get the header */
  882.      parseHeader(iw, n);
  883.      /* get the menu items */
  884.      parseMenu(iw, n);
  885.      /* get the cross reference entries */
  886.      parseXRefs(iw, n);
  887. }
  888.  
  889. Local void parseHeader(iw, n)
  890. InfoWidget iw;
  891. NodeInfo *n;
  892. {
  893.      String strpbrk(), tmp;
  894.      
  895.      /* first, get the node name offset */
  896.      I_START(n->name) = INTOFF(START(iw), NSEARCH(iw, n, NODE_TOKEN));
  897.      I_LEN(n->name) = INTOFF(START(iw), strpbrk(START(iw) + I_START(n->name),
  898.                         NAME_END_TOKEN)) -
  899.                              I_START(n->name);
  900.      
  901.      /* now the prev, if any */
  902.      if ((I_START(n->prev) = INTOFF(START(iw),
  903.                     NSEARCH(iw, n, PREV_TOKEN))) > 0)
  904.       I_LEN(n->prev) = INTOFF(START(iw),
  905.                   strpbrk(START(iw) + I_START(n->prev),
  906.                       NAME_END_TOKEN)) -
  907.                            I_START(n->prev);
  908.      else
  909.       I_LEN(n->prev) = I_START(n->prev) = 0;
  910.      
  911.      /* and the up, if any */
  912.      if ((I_START(n->up) = INTOFF(START(iw),
  913.                   NSEARCH(iw, n, UP_TOKEN))) > 0)
  914.       I_LEN(n->up) = INTOFF(START(iw), strpbrk(START(iw) + I_START(n->up),
  915.                            NAME_END_TOKEN)) -
  916.                             I_START(n->up);
  917.      else
  918.       I_LEN(n->up) = I_START(n->up) = 0;
  919.      
  920.      /* the next, if any */
  921.      if ((I_START(n->next) = INTOFF(START(iw),
  922.                     NSEARCH(iw, n, NEXT_TOKEN))) > 0)
  923.       I_LEN(n->next) = INTOFF(START(iw),
  924.                   strpbrk(START(iw) + I_START(n->next),
  925.                       NAME_END_TOKEN)) -
  926.                            I_START(n->next);
  927.      else
  928.       I_LEN(n->next) = I_START(n->next) = 0;
  929.      
  930.      /* And finally skip over the header and set the text offset there */
  931.      tmp = START(iw) + I_START(n->name);
  932.      while (*tmp != '\n')
  933.       tmp++;
  934.      I_START(n->text) = INTOFF(START(iw), tmp + 1);
  935.      I_LEN(n->text) = n->length - (I_START(n->text) - n->start);
  936. }
  937.  
  938. Local void parseMenu(iw, n)
  939. InfoWidget iw;
  940. NodeInfo *n;
  941. {
  942.      register String mstart;
  943.      String strpbrk();
  944.      
  945.      /* start clean */
  946.      FREE_LIST(n->menu);
  947.      
  948.      /* Does node have a menu? */
  949.      if ((mstart = NSEARCH(iw, n, MENU_TOKEN)) != NULL) {
  950.       /* Initialize string list */
  951.       ALLOC_LIST(n->menu);
  952.       
  953.       /* go looking for menu items */
  954.       while (mstart = search(iw, mstart, NEND(iw, n), MENU_SEP_TOKEN,
  955.                  FALSE)) {
  956.            MAYBE_BUMP_LIST(n->menu);
  957.            /* put an offset entry in the table */
  958.            I_LEN(TPOS(n->menu.t)) = 0;
  959.            I_START(TPOS(n->menu.t)) = INTOFF(START(iw), mstart);
  960.            while (*(mstart++) != ':')
  961.             I_LEN(TPOS(n->menu.t))++;
  962.            /* now save the menu name as a string in the list */
  963.            LPOS(n->menu) = XtMalloc(I_LEN(TPOS(n->menu.t)) + 1);
  964.            strncpy(LPOS(n->menu), START(iw) + I_START(TPOS(n->menu.t)),
  965.                I_LEN(TPOS(n->menu.t)));
  966.            LPOS(n->menu)[I_LEN(TPOS(n->menu.t))] = '\0';
  967.            normalize_whitespace(LPOS(n->menu));
  968.            /* Is the menu name not the node name? */
  969.            if (*mstart != ':') {
  970.             int plev = 0;
  971.             
  972.             mstart = eat_whitespace(mstart);
  973.             I_START(TPOS(n->menu.t)) = INTOFF(START(iw), mstart);
  974.             while (*mstart != '\0' && !(plev == 0 &&
  975.                         index(NAME_END_TOKEN,
  976.                               *mstart) != NULL)) {
  977.              if (*mstart == '(')
  978.                   ++plev;
  979.              else if (*mstart == ')')
  980.                   --plev;
  981.              mstart++;
  982.              }
  983.             I_LEN(TPOS(n->menu.t)) =
  984.              INTOFF(START(iw), mstart) - I_START(TPOS(n->menu.t));
  985.            }
  986.            INCP(n->menu.t);
  987.       }
  988.       ROUND_LIST(n->menu);
  989.      }
  990. }
  991.  
  992. Local void parseXRefs(iw, n)
  993. InfoWidget iw;
  994. NodeInfo *n;
  995. {
  996.      register String nstart;
  997.      String strpbrk();
  998.      
  999.      /* start clean */
  1000.      FREE_LIST(n->xref);
  1001.      
  1002.      /* Do we have any cross-reference entries? */
  1003.      if ((nstart = search(iw, NSTART(iw, n), NEND(iw, n), NOTE_TOKEN, TRUE))
  1004.      != NULL) {
  1005.       ALLOC_LIST(n->xref);
  1006.       nstart = NSTART(iw, n);
  1007.       
  1008.       /*
  1009.        * Go looking for cross-references (including the one we just
  1010.        * found; wasteful, but avoiding it would make for grotty code).
  1011.         */
  1012.       while (nstart = search(iw, nstart, NEND(iw, n), NOTE_TOKEN, TRUE)) {
  1013.            /* skip over whitespace */
  1014.            nstart = eat_whitespace(nstart);
  1015.            MAYBE_BUMP_LIST(n->xref);
  1016.            I_LEN(TPOS(n->xref.t)) = 0;
  1017.            I_START(TPOS(n->xref.t)) = INTOFF(START(iw), nstart);
  1018.            while (*(nstart++) != ':')
  1019.             I_LEN(TPOS(n->xref.t))++;
  1020.            /* save the note name as a string */
  1021.            LPOS(n->xref) = XtMalloc(I_LEN(TPOS(n->xref.t)) + 1);
  1022.            strncpy(LPOS(n->xref), START(iw) + I_START(TPOS(n->xref.t)),
  1023.                I_LEN(TPOS(n->xref.t)));
  1024.            LPOS(n->xref)[I_LEN(TPOS(n->xref.t))] = '\0';
  1025.            normalize_whitespace(LPOS(n->xref));
  1026.            /* Is the note name not the first part? */
  1027.            if (*nstart != ':') {
  1028.             nstart = eat_whitespace(nstart + 1);
  1029.             I_START(TPOS(n->xref.t)) = INTOFF(START(iw), nstart);
  1030.             I_LEN(TPOS(n->xref.t)) =
  1031.              INTOFF(START(iw), strpbrk(nstart, NAME_END_TOKEN)) -
  1032.                   I_START(TPOS(n->xref.t));
  1033.            }
  1034.            INCP(n->xref.t);
  1035.       }
  1036.       ROUND_LIST(n->xref);
  1037.      }
  1038. }           
  1039.  
  1040. /* Put the node information on the screen */
  1041. Local void displayNode(iw, n)
  1042. InfoWidget iw;
  1043. NodeInfo *n;
  1044. {
  1045.      Arg args[5];
  1046.      Cardinal i, lst_size;
  1047.      String *lst;
  1048.      Local char *nolist[] = { "", NULL };     /* make the list widget happy */
  1049.      Local char tmpfile[256];
  1050.      
  1051.      /* Make sure it doesn't try anything cute until we're ready */
  1052.      XawTextDisableRedisplay(iw->info.nodeText);
  1053.      
  1054.      /*
  1055.       * There exists a strange bug in the text widget that causes text
  1056.       * to be erroneously selected when we're mousing selections. Since
  1057.       * we don't want to keep things selected while we're navigating
  1058.       * anyway, this is a satisfactory workaround.
  1059.       */
  1060.      XawTextUnsetSelection(iw->info.nodeText);
  1061.      
  1062.      /* show the header */
  1063.      displayHeader(iw, n);
  1064.      
  1065.      /* show the menu */
  1066.      if (!n->menu.l) {
  1067.       lst = nolist;
  1068.       lst_size = 1;
  1069.      }
  1070.      else {
  1071.       lst = n->menu.l;
  1072.       lst_size = IDX(n->menu.t);
  1073.      }
  1074.      XawListChange(iw->info.menuList, lst, lst_size, 0, TRUE);
  1075.      
  1076.      /* change the xref list */
  1077.      if (!n->xref.l) {
  1078.       lst = nolist;
  1079.       lst_size = 1;
  1080.      }
  1081.      else {
  1082.       lst = n->xref.l;
  1083.       lst_size = IDX(n->xref.t);
  1084.      }
  1085.      XawListChange(iw->info.xrefList, lst, lst_size, 0, TRUE);
  1086.      
  1087.      /* Show the new text */
  1088.      i = 0;
  1089.      if (I_START(n->text)) {
  1090.       char *addr = (START(iw) + I_START(n->text) + I_LEN(n->text));
  1091.       
  1092.       XtSetArg(args[i], XtNstring, START(iw) + I_START(n->text));    i++;
  1093.       XtSetArg(args[i], XtNlength, I_LEN(n->text));            i++;
  1094.       if (INFO_CHAR(*addr))
  1095.            *addr = '\0';
  1096.       else {
  1097.            char msg[256];
  1098.            
  1099.            sprintf(msg, "Encountered bad terminator (%d) for node '%s'",
  1100.                *addr, n->name);
  1101.            XtWarning(msg);
  1102.       }
  1103.      }
  1104.      else {
  1105.       XtSetArg(args[i], XtNstring, START(iw));            i++;
  1106.       XtSetArg(args[i], XtNlength, DATASIZE(iw));            i++;
  1107.      }
  1108.      XtSetValues(iw->info.nodeText, args, i);
  1109.      
  1110.      /* Go for redisplay */
  1111.      XawTextEnableRedisplay(iw->info.nodeText);
  1112.      
  1113.      /* Stick the insertion marker at the top where it's out of the way */
  1114.      XawTextSetInsertionPoint(iw->info.nodeText, 0);
  1115. }
  1116.  
  1117. /* display the header information */
  1118. Local void displayHeader(iw, n)
  1119. InfoWidget iw;
  1120. NodeInfo *n;
  1121. {
  1122.      Arg args[5];
  1123.      Cardinal i;
  1124.      String tmp;
  1125.      int sensitive;
  1126.      
  1127.      /* set the file name */
  1128.      tmp = strconcat("File: ", file_name(iw->info.file));
  1129.      i = 0;
  1130.      XtSetArg(args[i], XtNlabel, tmp);                    i++;
  1131.      XtSetValues(iw->info.fileLabel, args, i);
  1132.      
  1133.      /* set the node name */
  1134.      i = 0;
  1135.      if ((tmp = offsetToString(iw, n->name)) != NULL)
  1136.       sensitive = TRUE;
  1137.      else
  1138.       sensitive = FALSE;
  1139.      XtSetArg(args[i], XtNlabel, strconcat("Node: ", tmp));        i++;
  1140.      XtSetArg(args[i], XtNsensitive, sensitive);            i++;
  1141.      XtSetValues(iw->info.nodeLabel, args, i);
  1142.      
  1143.      /* set the prev */
  1144.      i = 0;
  1145.      if ((tmp = offsetToString(iw, n->prev)) != NULL)
  1146.       sensitive = TRUE;
  1147.      else
  1148.       sensitive = FALSE;
  1149.      XtSetArg(args[i], XtNlabel, strconcat("Prev: ", tmp));        i++;
  1150.      XtSetArg(args[i], XtNsensitive, sensitive);            i++;
  1151.      XtSetValues(iw->info.prevCmd, args, i);
  1152.      
  1153.      /* set the up */
  1154.      i = 0;
  1155.      if ((tmp = offsetToString(iw, n->up)) != NULL)
  1156.       sensitive = TRUE;
  1157.      else
  1158.       sensitive = FALSE;
  1159.      XtSetArg(args[i], XtNlabel, strconcat("Up: ", tmp));        i++;
  1160.      XtSetArg(args[i], XtNsensitive, sensitive);            i++;
  1161.      XtSetValues(iw->info.upCmd, args, i);
  1162.      
  1163.      /* set the next */
  1164.      i = 0;
  1165.      if ((tmp = offsetToString(iw, n->next)) != NULL)
  1166.       sensitive = TRUE;
  1167.      else
  1168.       sensitive = FALSE;
  1169.      XtSetArg(args[i], XtNlabel, strconcat("Next: ", tmp));        i++;
  1170.      XtSetArg(args[i], XtNsensitive, sensitive);            i++;
  1171.      XtSetValues(iw->info.nextCmd, args, i);
  1172. }
  1173.  
  1174. /*
  1175.  * Look for tag table information in the current buffer. If tag table
  1176.  * is indirect, return TRUE, else return false.
  1177.  */
  1178. Local Boolean parseTags(iw)
  1179. InfoWidget iw;
  1180. {
  1181.      String start, s1;
  1182.      char tmp[MAXSTR];
  1183.      Boolean indirect = FALSE;
  1184.      int i;
  1185.      
  1186.      /*
  1187.       * go back about 8 lines. I don't know if this will always back up
  1188.       * past the end marker, but Emacs info seems to think so.
  1189.       */
  1190.      start = END(iw);
  1191.      i = 0;
  1192.      while (i < 8)
  1193.       if (*(--start) == '\n')
  1194.            i++;
  1195.      
  1196.      start = search(iw, start, END(iw), TAGEND_TOKEN, TRUE);
  1197.      if (start && (start = search_back(iw, start, START(iw),
  1198.                        TAGTABLE_TOKEN, TRUE))) {
  1199.       ALLOC_TABLE(TAGTABLE(iw));
  1200.       /* we were searching backward so move over the token */
  1201.       start += strlen(TAGTABLE_TOKEN);
  1202.       if ((s1 = search(iw, start, start + strlen(ITAGTABLE_TOKEN) + 10,
  1203.                ITAGTABLE_TOKEN, TRUE)) != NULL) {
  1204.            indirect = TRUE;
  1205.            start = s1;
  1206.       }
  1207.       while ((start = search(iw, start, END(iw), NODE_TOKEN, FALSE))
  1208.          != NULL) {
  1209.            MAYBE_BUMP_TABLE(TAGTABLE(iw));
  1210.            strccpy(tmp, start, DEL_CHAR);
  1211.            I_NAME(TPOS(TAGTABLE(iw))) = XtNewString(tmp);
  1212.            start += strlen(tmp) + 1;
  1213.            sscanf(start, "%d", &I_OFFSET(TPOS(TAGTABLE(iw))));
  1214.            INCP(TAGTABLE(iw));
  1215.       }
  1216.       ROUND_TABLE(TAGTABLE(iw));
  1217.      }
  1218.      else if (TAGTABLE(iw).table)
  1219.       FREE_TAG_TABLE(TAGTABLE(iw));
  1220.      return indirect;
  1221. }
  1222.  
  1223. /* Look for indirect file information in the current buffer */
  1224. Local void parseIndirect(iw, needIndirect)
  1225. InfoWidget iw;
  1226. Boolean needIndirect;
  1227. {
  1228.      String start;
  1229.      char tmp[MAXSTR], *s1;
  1230.      
  1231.      if (start = search(iw, START(iw), END(iw), INDIRECT_TOKEN, TRUE)) {
  1232.       /* move backwards looking for the INFO_CHAR */
  1233.       for (s1 = start; s1 >= START(iw) && !INFO_CHAR(*s1); s1--);
  1234.       if (s1 < START(iw)) {
  1235.            message(iw, "?Invalid indirect table for %s!", iw->info.file);
  1236.            return;
  1237.       }
  1238.       else
  1239.            HDRSIZE(iw) = INTOFF(START(iw), s1);
  1240.       ALLOC_TABLE(INDIRECT(iw));
  1241.       for (IDX(INDIRECT(iw)) = 0; !INFO_CHAR(*start); INCP(INDIRECT(iw))){
  1242.            MAYBE_BUMP_TABLE(INDIRECT(iw));
  1243.            strccpy(tmp, start, ':');
  1244.            I_NAME(TPOS(INDIRECT(iw))) = XtNewString(tmp);
  1245.            start += strlen(tmp) + 1;
  1246.            sscanf(start, "%d", &I_OFFSET(TPOS(INDIRECT(iw))));
  1247.            start = index(start, '\n') + 1;
  1248.       }
  1249.       ROUND_TABLE(INDIRECT(iw));
  1250.      }
  1251.      else if (needIndirect)
  1252.       message(iw, "?Indirect table not found for %s! Hilfe!",
  1253.           iw->info.file);
  1254.      else if (INDIRECT(iw).table)
  1255.       FREE_TAG_TABLE(INDIRECT(iw));
  1256. }
  1257.  
  1258. /*****************************************************************************
  1259.  * Text display functions.                                                   *
  1260.  *****************************************************************************/
  1261.  
  1262. /* display a message in the message area */
  1263. Local void message(iw, s, p1, p2, p3)
  1264. InfoWidget iw;
  1265. String s;
  1266. caddr_t p1, p2, p3;
  1267. {
  1268.      char msgbuf[MAXSTR];
  1269.      Arg args[5];
  1270.      Cardinal i;
  1271.      
  1272.      i = 0;
  1273.      if (s) {
  1274.       sprintf(msgbuf, s, p1, p2, p3);
  1275.       XtSetArg(args[i], XtNlabel, msgbuf);    i++;
  1276.       XtSetValues(iw->info.messageLabel, args, i);
  1277.       feep(iw);
  1278.       if (*s == '?')    /* a dire warning */
  1279.            XtWarning(msgbuf);
  1280.      }
  1281.      else {    /* clear the message area */
  1282.       XtSetArg(args[i], XtNlabel, " ");    i++;
  1283.       XtSetValues(iw->info.messageLabel, args, i);
  1284.      }
  1285. }
  1286.  
  1287. /* display the current node/file */
  1288. Local void showStatus(iw, n)
  1289. InfoWidget iw;
  1290. NodeInfo *n;
  1291. {
  1292.      char statbuf[MAXSTR];
  1293.      Arg args[5];
  1294.      Cardinal i;
  1295.      String sub = iw->info.subFile;
  1296.      
  1297.      sprintf(statbuf, "(%s)%s, %d characters%s", file_name(iw->info.file),
  1298.          iw->info.node, n->length,
  1299.          sub ? strconcat(", subfile: ", sub) : ".");
  1300.      i = 0;
  1301.      XtSetArg(args[i], XtNlabel, statbuf);    i++;
  1302.      XtSetValues(iw->info.statusLabel, args, i);
  1303. }
  1304.  
  1305. /*****************************************************************************
  1306.  * Functions used by actions                                                 *
  1307.  *****************************************************************************/
  1308.  
  1309. Local void Abort(w, event, params, num_params)
  1310. Widget   w;
  1311. XEvent   *event;
  1312. String   *params;
  1313. Cardinal *num_params;
  1314. {
  1315.      InfoWidget iw = find_top(w);
  1316.      
  1317.      feep(iw);
  1318.      do_dialog_abort(w, iw, NULL);
  1319. }
  1320.  
  1321. Local void Confirm(w, event, params, num_params)
  1322. Widget   w;
  1323. XEvent   *event;
  1324. String   *params;
  1325. Cardinal *num_params;
  1326. {
  1327.      InfoWidget iw = find_top(w);
  1328.      
  1329.      if (w == iw->info.argText)
  1330.       (*(iw->info.requester))(w, iw, NULL);
  1331.      else
  1332.       do_dialog_confirm(w, iw, NULL);
  1333. }
  1334.  
  1335. Local void NodeDir(w, event, params, num_params)
  1336. Widget   w;
  1337. XEvent   *event;
  1338. String   *params;
  1339. Cardinal *num_params;
  1340. {
  1341.      InfoWidget iw = find_top(w);
  1342.      
  1343.      if (getNode(iw, "dir", "Top", NULL) == FALSE)
  1344.       message(iw, "?Yow! The directory seems to have disappeared!\n");
  1345. }
  1346.  
  1347. Local void NodeNext(w, event, params, num_params)
  1348. Widget   w;
  1349. XEvent   *event;
  1350. String   *params;
  1351. Cardinal *num_params;
  1352. {
  1353.      do_next(NULL, find_top(w), NULL);
  1354. }
  1355.  
  1356. Local void NodePrev(w, event, params, num_params)
  1357. Widget   w;
  1358. XEvent   *event;
  1359. String   *params;
  1360. Cardinal *num_params;
  1361. {
  1362.      do_prev(NULL, find_top(w), NULL);
  1363. }
  1364.  
  1365.  
  1366. Local void NodeUp(w, event, params, num_params)
  1367. Widget   w;
  1368. XEvent   *event;
  1369. String   *params;
  1370. Cardinal *num_params;
  1371. {
  1372.      do_up(NULL, find_top(w), NULL);
  1373. }
  1374.  
  1375. Local void NodeTop(w, event, params, num_params)
  1376. Widget   w;
  1377. XEvent   *event;
  1378. String   *params;
  1379. Cardinal *num_params;
  1380. {
  1381.      InfoWidget iw = find_top(w);
  1382.      
  1383.      if (getNode(iw, NULL, "Top", NULL) == FALSE)
  1384.       message(iw, "?This node has no top! Bad joss!");
  1385. }
  1386.  
  1387. Local void NodeLast(w, event, params, num_params)
  1388. Widget   w;
  1389. XEvent   *event;
  1390. String   *params;
  1391. Cardinal *num_params;
  1392. {
  1393.      NodeInfo *tmp;
  1394.      InfoWidget iw = find_top(w);
  1395.      
  1396.      if ((tmp = popNode(iw)) != NULL) {
  1397.       if (getNode(iw, tmp->file, tmp->node, tmp) == FALSE)
  1398.            message(iw, "?Can't pop back to node (%s)%s! We're hosed!",
  1399.                tmp->file, tmp->node);
  1400.      }
  1401.      else
  1402.       message(iw, "No further history.");
  1403. }
  1404.  
  1405. Local void NodeXRef(w, event, params, num_params)
  1406. Widget   w;
  1407. XEvent   *event;
  1408. String   *params;
  1409. Cardinal *num_params;
  1410. {
  1411.      do_xref(NULL, find_top(w), NULL);
  1412. }
  1413.  
  1414. Local void NodeGoto(w, event, params, num_params)
  1415. Widget   w;
  1416. XEvent   *event;
  1417. String   *params;
  1418. Cardinal *num_params;
  1419. {
  1420.      do_goto(NULL, find_top(w), NULL);
  1421. }
  1422.  
  1423. Local void NodeSearch(w, event, params, num_params)
  1424. Widget   w;
  1425. XEvent   *event;
  1426. String   *params;
  1427. Cardinal *num_params;
  1428. {
  1429.      do_search(NULL, find_top(w), NULL);
  1430. }
  1431.  
  1432. Local void NodeQuit(w, event, params, num_params)
  1433. Widget   w;
  1434. XEvent   *event;
  1435. String   *params;
  1436. Cardinal *num_params;
  1437. {
  1438.      do_quit(NULL, find_top(w), NULL);
  1439. }
  1440.  
  1441. Local void NodeTutorial(w, event, params, num_params)
  1442. Widget   w;
  1443. XEvent   *event;
  1444. String   *params;
  1445. Cardinal *num_params;
  1446. {
  1447.      InfoWidget iw = find_top(w);
  1448.      
  1449.      if (getNode(iw, "info", "Help", NULL) == FALSE)
  1450.       message(iw, "?Hmmm. I can't seem to find the info tutorial!");
  1451. }
  1452.  
  1453. Local void NodeHelp(w, event, params, num_params)
  1454. Widget   w;
  1455. XEvent   *event;
  1456. String   *params;
  1457. Cardinal *num_params;
  1458. {
  1459.      Cardinal i;
  1460.      Arg args[10];
  1461.      InfoWidget iw = find_top(w);
  1462.      
  1463.      if (!iw->info.helpPopup) {
  1464.       Widget hpane, htext;
  1465.       Local XtCallbackRec cb[2];
  1466.       
  1467.       /* create the help popup */
  1468.       i = 0;
  1469.       iw->info.helpPopup = XtCreatePopupShell("help",
  1470.                           transientShellWidgetClass,
  1471.                           iw, args, i);
  1472.       i = 0;
  1473.       hpane = XtCreateManagedWidget("pane", panedWidgetClass,
  1474.                     iw->info.helpPopup, args, i);
  1475.       i = 0;
  1476.       cb[0].callback = do_popdown;
  1477.       cb[0].closure = (caddr_t)iw->info.helpPopup;
  1478.       XtSetArg(args[i], XtNcallback, cb);            i++;
  1479.       XtCreateManagedWidget("Close", commandWidgetClass,
  1480.                 hpane, args, i);
  1481.       i = 0;
  1482.       XtSetArg(args[i], XtNtype, XawAsciiString);        i++;
  1483.       XtSetArg(args[i], XtNeditType, XawtextRead);        i++;
  1484.       htext = XtCreateManagedWidget("text", asciiTextWidgetClass,
  1485.                     hpane, args, i);
  1486.      }
  1487.      
  1488.      i = 0;
  1489.      XtSetArg(args[i], XtNx, event->xbutton.x);            i++;
  1490.      XtSetArg(args[i], XtNy, event->xbutton.y);            i++;
  1491.      XtSetValues(iw->info.helpPopup, args, i);
  1492.      
  1493.      XtPopup(iw->info.helpPopup, XtGrabNonexclusive);
  1494. }
  1495.  
  1496. Local void ButtonSelection(w, event, params, num_params)
  1497. Widget   w;
  1498. XEvent   *event;
  1499. String   *params;
  1500. Cardinal *num_params;
  1501. {
  1502.      char tmp[MAXTOKEN], *idx;
  1503.      XawTextPosition beg, end, nlen;
  1504.      XawTextBlock ret, asterisk, colon;
  1505.      InfoWidget iw = find_top(w);
  1506.      
  1507.      SET_BLOCK(asterisk, 0, 1, "*");
  1508.      SET_BLOCK(colon, 0, 1, ":");
  1509.      
  1510.      /* Next, try and get a complete "item" selected */
  1511.      if ((beg = XawTextSearch(w, XawsdLeft, &asterisk)) != XawTextSearchError)
  1512.       XawTextSetInsertionPoint(w, beg);
  1513.      else
  1514.       return;    /* Bomb out */
  1515.      if ((end = XawTextSearch(w, XawsdRight, &colon)) != XawTextSearchError &&
  1516.      end > beg) {
  1517.       long len = end - beg;
  1518.       
  1519.       /* Victory! Now try and figure out what it is */
  1520.       if (!XawTextSourceRead(XawTextGetSource(w), beg, &ret, len))
  1521.            return;    /* If can't read, forget it */
  1522.       else while (ret.length && *(ret.ptr) == '*' || isspace(*(ret.ptr)))
  1523.            --ret.length, ++ret.ptr;
  1524.       if (!ret.length || ret.length >= MAXTOKEN) {
  1525.            feep(iw);
  1526.            return;    /* Nothing left, forget it */
  1527.           }
  1528.       else {
  1529.            strncpy(tmp, ret.ptr, ret.length);
  1530.            tmp[ret.length] = '\0';
  1531.            normalize_whitespace(tmp);
  1532.            if (!strncomp(tmp, "note ", 5)) {
  1533.             if (!(idx = trueName(iw, CURNODE(iw)->xref, tmp + 5)))
  1534.              feep(iw);
  1535.             else if (getNode(iw, NULL, idx, NULL) == FALSE)
  1536.              message(iw, "?Can't find cross reference for '%s'!",
  1537.                  idx);
  1538.            }
  1539.            else {
  1540.             if (!(idx = trueName(iw, CURNODE(iw)->menu, tmp)))
  1541.              feep(iw);
  1542.             else if (getNode(iw, NULL, idx, NULL) == FALSE)
  1543.              message(iw, "?Can't find menu entry for '%s'!",
  1544.                  idx);
  1545.            }
  1546.       }            
  1547.      }
  1548. }
  1549.  
  1550. Local void NodeMenuSelectByNumber(w, event, params, num_params)
  1551. Widget   w;
  1552. XEvent   *event;
  1553. String   *params;
  1554. Cardinal *num_params;
  1555. {
  1556.      Import int atoi();
  1557.      int menunum;
  1558.      int nitems;
  1559.      InfoWidget iw = find_top(w);
  1560.      
  1561.      nitems = IDX(CURNODE(iw)->menu.t);
  1562.      menunum = atoi(*params);
  1563.      /* menu number of zero means get menu from arg area */
  1564.      if (!menunum)
  1565.       do_menu(NULL, iw, NULL);
  1566.      else if (!nitems)
  1567.       message(iw, "No menu for this node.");
  1568.      else if (menunum > nitems)
  1569.       message(iw, "There are only %d menu items.", nitems);
  1570.      else {
  1571.       XawListHighlight(iw->info.menuList, menunum - 1);
  1572.       if (getNode(iw, NULL,
  1573.               offsetToString(iw,CURNODE(iw)->menu.t.table[menunum-1]),
  1574.               NULL) == FALSE)
  1575.            message(iw, "?Can't find node for menu item #%s", *params);
  1576.      }
  1577. }
  1578.  
  1579. Local void NodePrint(w, event, params, num_params)
  1580. Widget   w;
  1581. XEvent   *event;
  1582. String   *params;
  1583. Cardinal *num_params;
  1584. {
  1585.      Import int unlink();
  1586.      String tmp;
  1587.      FILE *out;
  1588.      InfoWidget iw = find_top(w);
  1589.      
  1590.      /* if you don't have this routine in your stdlib, make one up */
  1591.      tmp = tmpnam(NULL);
  1592.      
  1593.      if (!CURNODE(iw))
  1594.       message(iw, "?No current node?");
  1595.      else if ((out = fopen(tmp, "w")) == NULL)
  1596.       message(iw, "?Can't open temporary file '%s'.", tmp);
  1597.      else {
  1598.       String s1 = NSTART(iw, CURNODE(iw));
  1599.       String s2 = NEND(iw, CURNODE(iw));
  1600.       char syscmd[MAXSTR];
  1601.       int stat;
  1602.       
  1603.       fwrite(s1, s2 - s1, 1, out);
  1604.       fclose(out);
  1605.       
  1606.       message(iw, "Sending '%s' to the printer, please wait..",
  1607.           iw->info.node);
  1608.       
  1609.       sprintf(syscmd, "%s %s", iw->info.printCmd, tmp);
  1610.       if ((stat = system(syscmd)) != 0)
  1611.            message(iw, "?'%s' failed with exit status %d. Help!",
  1612.                syscmd, stat);
  1613.       else
  1614.            message(iw, "Finished printing.");
  1615.       unlink(tmp);
  1616.      }
  1617.      
  1618.      
  1619. }
  1620.  
  1621. /*****************************************************************************
  1622.  * Functions used from callback lists.                                       *
  1623.  *****************************************************************************/
  1624.  
  1625. /* Abort the dialog operation */
  1626. Local void do_dialog_abort(w, client_data, call_data)
  1627. Widget w;
  1628. caddr_t client_data;
  1629. caddr_t call_data;
  1630. {
  1631.      InfoWidget iw = (InfoWidget)client_data;
  1632.      
  1633.      if (w == iw->info.argText)
  1634.       clear_arg(iw);
  1635.      else
  1636.       XtDestroyWidget(iw->info.argPopup);
  1637. }
  1638.  
  1639. /* Confirm the dialog operation */
  1640. Local void do_dialog_confirm(w, client_data, call_data)
  1641. Widget w;
  1642. caddr_t client_data;
  1643. caddr_t call_data;
  1644. {
  1645.      InfoWidget iw = (InfoWidget)client_data;
  1646.      XawTextBlock blk;
  1647.      
  1648.      XtDestroyWidget(iw->info.argPopup);
  1649.      
  1650.      SET_BLOCK(blk, 0, 0, NULL);
  1651.      if ((blk.ptr = XawDialogGetValueString(XtParent(w))) &&
  1652.      (blk.length = strlen(blk.ptr))) {
  1653.       if (blk.length > ARGLEN)    /* truncate if necessary */
  1654.            blk.ptr[blk.length = ARGLEN] = '\0';
  1655.       XawTextReplace(iw->info.argText, 0, blk.length, &blk);
  1656.       (*(iw->info.requester))(w, iw, NULL);
  1657.      }
  1658. }
  1659.  
  1660. /*
  1661.  * Seems there should be a better way of doing this. Methinks the
  1662.  * XtCallbackPopdown() stuff isn't general enough. Should be a way of
  1663.  * doing this (and only this).
  1664.  */
  1665. Local void do_popdown(w, client_data, call_data)
  1666. Widget w;
  1667. caddr_t client_data;
  1668. caddr_t call_data;
  1669. {
  1670.      XtPopdown((Widget)client_data);
  1671. }
  1672.  
  1673. Local void do_prev(w, client_data, call_data)
  1674. Widget w;
  1675. caddr_t client_data;
  1676. caddr_t call_data;
  1677. {
  1678.      InfoWidget iw = (InfoWidget)client_data;
  1679.      String tmp;
  1680.      
  1681.      if ((tmp = offsetToString(iw, CURNODE(iw)->prev))) {
  1682.       if (getNode(iw, NULL, tmp, NULL) == FALSE)
  1683.            message(iw, "?Can't find the previous (%s) for this node.",
  1684.                tmp);
  1685.      }
  1686.      else
  1687.       message(iw, "Node has no previous");
  1688. }
  1689.  
  1690. Local void do_quit(w, client_data, call_data)
  1691. Widget w;
  1692. caddr_t client_data;
  1693. caddr_t call_data;
  1694. {
  1695.      InfoWidget iw = (InfoWidget)client_data;
  1696.      
  1697.      if (XtHasCallbacks(iw, XtNcallback) != XtCallbackHasSome)
  1698.       message(iw, "Sorry, I just don't know how to quit.");
  1699.      else
  1700.       XtCallCallbacks(iw, XtNcallback, NULL);
  1701. }
  1702.  
  1703. Local void do_up(w, client_data, call_data)
  1704. Widget w;
  1705. caddr_t client_data;
  1706. caddr_t call_data;
  1707. {
  1708.      InfoWidget iw = (InfoWidget)client_data;
  1709.      String tmp;
  1710.      
  1711.      if ((tmp = offsetToString(iw, CURNODE(iw)->up))) {
  1712.       if (getNode(iw, NULL, tmp, NULL) == FALSE)
  1713.            message(iw, "?Can't find the up (%s) for this node.", tmp);
  1714.      }
  1715.      else
  1716.       message(iw, "Node has no up");
  1717. }
  1718.  
  1719. Local void do_next(w, client_data, call_data)
  1720. Widget w;
  1721. caddr_t client_data;
  1722. caddr_t call_data;
  1723. {
  1724.      InfoWidget iw = (InfoWidget)client_data;
  1725.      String tmp;
  1726.      
  1727.      if ((tmp = offsetToString(iw, CURNODE(iw)->next))) {
  1728.       if (getNode(iw, NULL, tmp, NULL) == FALSE)
  1729.            message(iw, "?Can't find the next (%s) for this node.", tmp);
  1730.      }
  1731.      else
  1732.       message(iw, "Node has no next");
  1733. }
  1734.  
  1735. Local void do_xref(w, client_data, call_data)
  1736. Widget w;
  1737. caddr_t client_data;
  1738. caddr_t call_data;
  1739. {
  1740.      InfoWidget iw = (InfoWidget)client_data;
  1741.      String tmp;
  1742.      
  1743.      if ((tmp = get_arg(iw)) != NULL) {
  1744.       if ((tmp = trueName(iw, CURNODE(iw)->xref, tmp)) == NULL)
  1745.            message(iw, "No cross reference entry named '%s' in this node.",
  1746.                get_arg(iw));
  1747.       else if (getNode(iw, NULL, tmp, NULL) == FALSE)
  1748.            message(iw, "?Can't find node for xref item '%s'!",
  1749.                get_arg(iw));
  1750.      }
  1751.      else
  1752.       dialog(iw, "Please specify a cross reference:", do_xref);
  1753. }
  1754.  
  1755. Local void do_menu(w, client_data, call_data)
  1756. Widget w;
  1757. caddr_t client_data;
  1758. caddr_t call_data;
  1759. {
  1760.      InfoWidget iw = (InfoWidget)client_data;
  1761.      String tmp;
  1762.      
  1763.      if ((tmp = get_arg(iw)) != NULL) {
  1764.       if ((tmp = trueName(iw, CURNODE(iw)->menu, tmp)) == NULL)
  1765.            message(iw, "No menu entry named '%s' in this node.",
  1766.                get_arg(iw));
  1767.       else if (getNode(iw, NULL, tmp, NULL) == FALSE)
  1768.            message(iw, "?Can't find node for menu item '%s'",
  1769.                get_arg(iw));
  1770.      }
  1771.      else
  1772.       dialog(iw, "Please specify a menu entry:", do_menu);
  1773. }
  1774.  
  1775. Local void do_goto(w, client_data, call_data)
  1776. Widget w;
  1777. caddr_t client_data;
  1778. caddr_t call_data;
  1779. {
  1780.      InfoWidget iw = (InfoWidget)client_data;
  1781.      String tmp;
  1782.      
  1783.      if ((tmp = get_arg(iw)) != NULL) {
  1784.       char saveit[ARGLEN];
  1785.       
  1786.       /*
  1787.            * The string tmp points to will get nuked if getNode() fails
  1788.        * (as part of the cleanup process), so we need to save it if
  1789.        * we want to be able to print a meaningful error message.
  1790.        */
  1791.       strcpy(saveit, tmp);
  1792.       if (getNode(iw, NULL, tmp, NULL) == FALSE)
  1793.            message(iw, "Can't find a node named %s", saveit);
  1794.      }
  1795.      else
  1796.       dialog(iw, "Please specify the name of a node to goto:", do_goto);
  1797. }
  1798.  
  1799. /*
  1800.  * Implement a somewhat simplistic search strategy. If file has an indirect
  1801.  * list, look for a match in the tag table (since just looking in the current
  1802.  * file probably wouldn't be very useful). If not, then search the current
  1803.  * file. If we're successful in either case, record the position (in the
  1804.  * tags table or the file) so that we don't hit it again right away.
  1805.  */
  1806. Local void do_search(w, client_data, call_data)
  1807. Widget w;
  1808. caddr_t client_data;
  1809. caddr_t call_data;
  1810. {
  1811.      InfoWidget iw = (InfoWidget)client_data;
  1812.      String tmp, s;
  1813.      char name[MAXSTR];
  1814.      Local struct {
  1815.       String file;
  1816.       caddr_t pos;
  1817.      } oldPos;
  1818.      
  1819.      if ((tmp = get_arg(iw)) != NULL) {
  1820.       /* if remembered position is invalid, reset it */
  1821.       if (strcomp(oldPos.file, iw->info.file)) {
  1822.            oldPos.file = iw->info.file;
  1823.            oldPos.pos = NULL;
  1824.       }
  1825.       if (INDIRECT(iw).table) {
  1826.            ID_P i;
  1827.            int len = strlen(tmp);
  1828.            
  1829.            if (oldPos.pos)
  1830.             i = (ID_P)oldPos.pos;
  1831.            else
  1832.             i = TAGTABLE(iw).table;
  1833.            /* do a tags search */
  1834.            while (I_NAME(*i)) {
  1835.             if (!strncomp(I_NAME(*i), tmp, len))
  1836.              break;
  1837.             i++;
  1838.            }
  1839.            /* success? */
  1840.            if (I_NAME(*i)) {
  1841.             oldPos.pos = (caddr_t)(i + 1);
  1842.             if (getNode(iw, iw->info.file, I_NAME(*i), NULL) == FALSE)
  1843.              message(iw, "?Can't find node for tag %s!",
  1844.                  I_NAME(*i));
  1845.            }
  1846.            else {
  1847.             message(iw, "Tag search for '%s' failed.", tmp);
  1848.             oldPos.pos = NULL;
  1849.            }
  1850.       }
  1851.       else {
  1852.            if (oldPos.pos)
  1853.             s = (String)oldPos.pos;
  1854.            else
  1855.             s = START(iw);
  1856.            if ((s = search(iw, s, END(iw), 
  1857.                    strconcat(NODE_TOKEN, tmp),
  1858.                    TRUE)) != NULL) {
  1859.             int i;
  1860.             
  1861.             oldPos.pos = (caddr_t)s;
  1862.             strcpy(name, tmp);
  1863.             i = strlen(name);
  1864.             while (!index(NAME, *s))
  1865.              name[i++] = *s++;
  1866.             name[i] = '\0';
  1867.             if (getNode(iw, iw->info.file, name, NULL) == FALSE)
  1868.              message(iw, "?Can't find node name in search!");
  1869.            }
  1870.            else {
  1871.             message(iw, "Search for '%s' failed.", tmp);
  1872.             oldPos.pos = NULL;
  1873.            }
  1874.       }
  1875.      }
  1876.      else
  1877.       dialog(iw, "Please enter a string to search for:", do_search);
  1878. }
  1879.  
  1880. /* These two handle selections from the menu and xref lists */
  1881.  
  1882. Local void do_menu_sel(w, client_data, call_data)
  1883. Widget w;
  1884. caddr_t client_data;
  1885. caddr_t call_data;
  1886. {
  1887.      InfoWidget iw = (InfoWidget)client_data;
  1888.      XawListReturnStruct *rs = (XawListReturnStruct *)call_data;
  1889.      
  1890.      if (getNode(iw, NULL, trueName(iw, CURNODE(iw)->menu, rs->string),
  1891.          NULL) == FALSE)
  1892.       message(iw, "?Can't find node for menu item '%s'", rs->string);
  1893. }
  1894.  
  1895. Local void do_xref_sel(w, client_data, call_data)
  1896. Widget w;
  1897. caddr_t client_data;
  1898. caddr_t call_data;
  1899. {
  1900.      InfoWidget iw = (InfoWidget)client_data;
  1901.      XawListReturnStruct *rs = (XawListReturnStruct *)call_data;
  1902.      
  1903.      if (getNode(iw, NULL, trueName(iw, CURNODE(iw)->xref, rs->string),
  1904.          NULL) == FALSE)
  1905.       message(iw, "?Can't find node for cross reference '%s'", rs->string);
  1906. }
  1907.  
  1908. /*****************************************************************************
  1909.  * Xlib and toolkit utility functions.                                       *
  1910.  *****************************************************************************/
  1911.  
  1912. /* Clear the argument text */
  1913. Local void clear_arg(iw)
  1914. InfoWidget iw;
  1915. {
  1916.      XawTextBlock blk;
  1917.      
  1918.      SET_BLOCK(blk, 0, 0, "");
  1919.      XawTextReplace(iw->info.argText, 0, strlen(iw->info.arg), &blk);
  1920. }
  1921.  
  1922. /* Put up a dialog to get necessary information */
  1923. Local void dialog(iw, msg, callback)
  1924. InfoWidget iw;
  1925. String msg;
  1926. void (*callback)();
  1927. {
  1928.      Arg args[10];
  1929.      Cardinal i;
  1930.      int x, y;
  1931.      Widget dg, abort, confirm;
  1932.      
  1933.      /*
  1934.       * We create the dialog everytime (rather than just once, followed
  1935.       * by Popup/Popdown requests) so that it will be made the proper size
  1936.       * for the label each time. Can't seem to get it to resize dynamically,
  1937.       * so I don't see any other way.
  1938.       */
  1939.      iw->info.requester = callback;
  1940.      
  1941.      /* Don't see any other way of doing this. It seems there should be. */
  1942.      getXY(iw, &x, &y);
  1943.      
  1944.      /* Position nicely */
  1945.      i = 0;
  1946.      XtSetArg(args[i], XtNx, x - 30 > 0 ? x - 30 : 0);    i++;
  1947.      XtSetArg(args[i], XtNy, y - 30 > 0 ? y - 30 : 0);    i++;
  1948.      XtSetArg(args[i], XtNallowShellResize, TRUE);    i++;
  1949.      iw->info.argPopup = XtCreatePopupShell("need_argument",
  1950.                         transientShellWidgetClass,
  1951.                         iw, args, i);
  1952.      i = 0;
  1953.      XtSetArg(args[i], XtNvalue, iw->info.arg);        i++;
  1954.      XtSetArg(args[i], XtNlabel, msg);            i++;
  1955.      dg = XtCreateManagedWidget("dialog", dialogWidgetClass,
  1956.                 iw->info.argPopup, args, i);
  1957.      
  1958.      i = 0;
  1959.      abort = XtCreateManagedWidget("abort", commandWidgetClass,
  1960.                    dg, args, i);
  1961.      XtAddCallback(abort, XtNcallback, do_dialog_abort, iw);
  1962.      
  1963.      i = 0;
  1964.      confirm = XtCreateManagedWidget("confirm", commandWidgetClass,
  1965.                      dg, args, i);
  1966.      XtAddCallback(confirm, XtNcallback, do_dialog_confirm, iw);
  1967.      
  1968.      XtPopup(iw->info.argPopup, XtGrabExclusive);
  1969. }
  1970.  
  1971. /* Toot the horn */
  1972. Local void feep(iw)
  1973. InfoWidget iw;
  1974. {
  1975.      XBell(XtDisplay(iw), iw->info.bell_volume);
  1976. }
  1977.  
  1978. /* Find the info widget in a hierarchy */
  1979. Local Inline InfoWidget find_top(w)
  1980. Widget w;
  1981. {
  1982.      register Widget tmp = w;
  1983.      
  1984.      while (tmp) {
  1985.       if (XtClass(tmp) == infoWidgetClass)
  1986.            return (InfoWidget)tmp;
  1987.       else
  1988.            tmp = XtParent(tmp);
  1989.      }
  1990.      if (!tmp)
  1991.       XtError("Walked off end of widget hierarchy!");
  1992.      return (InfoWidget)NULL;
  1993. }
  1994.  
  1995. /* Return the arg contents if set, else NULL */
  1996. Local String get_arg(w)
  1997. InfoWidget w;
  1998. {
  1999.      if (strlen(w->info.arg))
  2000.       return w->info.arg;
  2001.      else
  2002.       return NULL;
  2003. }
  2004.  
  2005. /* Return the root XY coords of the pointer */
  2006. Local void getXY(w, xp, yp)
  2007. Widget w;
  2008. int *xp, *yp;
  2009. {
  2010.      Window junkr, junkc;
  2011.      int junkx, junky;
  2012.      unsigned int mask;
  2013.      
  2014.      (void) XQueryPointer(XtDisplay(w), XtWindow(w), &junkr, &junkc,
  2015.               xp, yp, &junkx, &junky, &mask);
  2016. }
  2017.  
  2018. /*****************************************************************************
  2019.  * Unix and string utility functions.                                        *
  2020.  *****************************************************************************/
  2021.  
  2022. /* Search for a file along a path, returning the complete path name if found */
  2023. Local String find_file(path, name)
  2024. String path, name;
  2025. {
  2026.      String cp = path;
  2027.      Boolean more_path = TRUE;
  2028.      Local char dir[MAXPATHLEN];
  2029.      int status = -1;
  2030.      String name_start, z_start;
  2031.      
  2032.      dir[0] = '\0';
  2033.      
  2034.      /* absolute path name? */
  2035.      if (name[0] == '/') {
  2036.       if (!access(name, R_OK))
  2037.            return name;
  2038.       else
  2039.            name = file_name(name);
  2040.      }
  2041.      while (status && more_path) {
  2042.           if ((cp = index(path, ':')) != NULL) {
  2043.                strncpy(dir, path, cp - path);
  2044.            dir[cp - path] = '\0';
  2045.                strcat(dir, "/");
  2046.                path = cp + 1;
  2047.           }
  2048.           else {
  2049.                strcpy(dir, path);
  2050.                strcat(dir, "/");
  2051.                more_path = FALSE;
  2052.           } 
  2053.       name_start = dir+strlen(dir);
  2054.       strcat(dir, name);
  2055.           status = access(dir, R_OK);
  2056. #ifdef UNCOMPRESS
  2057.       if (status) {
  2058.            z_start = dir+strlen(dir);
  2059.            strcpy(z_start,".Z");
  2060.            status = access(dir, R_OK);
  2061.       }
  2062.       if (status) {
  2063.            strcpy(z_start,".z");
  2064.            status = access(dir, R_OK);
  2065.       }
  2066. #endif
  2067.       /* if we failed, try again in lower case */
  2068.       if (status) {
  2069.            downcase(name_start);
  2070. #ifdef UNCOMPRESS
  2071.            *z_start = '\0';
  2072. #endif
  2073.            status = access(dir, R_OK);
  2074. #ifdef UNCOMPRESS
  2075.            if (status) {
  2076.             strcpy(z_start,".Z");
  2077.             status = access(dir, R_OK);
  2078.            }
  2079.            if (status) {
  2080.             strcpy(z_start,".z");
  2081.             status = access(dir, R_OK);
  2082.            }
  2083. #endif
  2084.       }
  2085.      }
  2086.      if (dir[0])
  2087.           return dir;
  2088.      else
  2089.           return NULL;
  2090. }
  2091.  
  2092. /* return the file part of a path name */
  2093. Local Inline String file_name(s)
  2094. register String s;
  2095. {
  2096.      register int i = strlen(s);
  2097.      
  2098.      while (i) {
  2099.       if (s[i - 1] == '/')
  2100.            return s + i;
  2101.       i--;
  2102.      }
  2103.      return s;
  2104. }
  2105.  
  2106. /* strip evil tab/formfeed/newline chars from a string (replacing w/blanks) */
  2107. Local Inline String normalize_whitespace(s)
  2108. String s;
  2109. {
  2110.      register String tmp;
  2111.      
  2112.      if (tmp = s) {
  2113.       while (*tmp) {
  2114.            if (isspace(*tmp))
  2115.             *tmp = ' ';
  2116.            ++tmp;
  2117.       }
  2118.      }
  2119.      return s;
  2120. }
  2121.  
  2122. /* Convert from an offset ID to a string. */
  2123. Local Inline String offsetToString(iw, blk)
  2124. InfoWidget iw;
  2125. ID blk;
  2126. {
  2127.      Local char ret[MAXSTR];
  2128.      
  2129.      if (I_LEN(blk) != 0) {
  2130.       strncpy(ret, START(iw) + I_START(blk), I_LEN(blk));
  2131.       ret[I_LEN(blk)] = '\0';
  2132.       return normalize_whitespace(ret);
  2133.      }
  2134.      else
  2135.       return NULL;
  2136. }
  2137.  
  2138. /* chew through white space */
  2139. Local Inline String eat_whitespace(s)
  2140. register String s;
  2141. {
  2142.      while (*s && isspace(*s))
  2143.       s++;
  2144.      return s;
  2145. }
  2146.  
  2147. /* look up the actual name of a list item */
  2148. Local String trueName(iw, lst, name)
  2149. InfoWidget iw;
  2150. IDList lst;
  2151. String name;
  2152. {
  2153.      register int i;
  2154.      
  2155.      for (i = 0; i < lst.t.idx; i++)
  2156.       if (!strcomp(lst.l[i], name))
  2157.            return offsetToString(iw, lst.t.table[i]);
  2158.      return NULL;
  2159. }
  2160.  
  2161. /* Search for a string */
  2162. Local String search(iw, start, end, str, igncase)
  2163. InfoWidget iw;
  2164. register String start, end, str;
  2165. Boolean igncase;
  2166. {
  2167.      register String ind = str;
  2168.      register String stop = str + strlen(str);
  2169.      register int comp;
  2170.      
  2171.      while (start < end) {
  2172.       if (!igncase)
  2173.            comp = (*start == *ind);
  2174.       else
  2175.            comp = (TOLOWER(*start) == TOLOWER(*ind));
  2176.       if (!comp) {
  2177.            if (ind != str)
  2178.             ind = str;
  2179.            else
  2180.             start++;
  2181.       }
  2182.       else {
  2183.            if (++start <= end && ++ind == stop)
  2184.             return start;
  2185.       }
  2186.      }
  2187.      return NULL;
  2188. }
  2189.  
  2190. /* Like search(), but in the reverse direction */
  2191. Local String search_back(iw, start, end, str, igncase)
  2192. InfoWidget iw;
  2193. register String start, end, str;
  2194. Boolean igncase;
  2195. {
  2196.      register String ind;
  2197.      register String stop;
  2198.      register int comp;
  2199.      
  2200.      ind = str = reverse(str);
  2201.      stop = ind + strlen(ind);
  2202.      
  2203.      while (start > end) {
  2204.       if (!igncase)
  2205.            comp = (*start == *ind);
  2206.       else
  2207.            comp = (TOLOWER(*start) == TOLOWER(*ind));
  2208.       if (!comp) {
  2209.            if (ind != str)
  2210.             ind = str;
  2211.            else
  2212.             start--;
  2213.       }
  2214.       else {
  2215.            start--;
  2216.            if (++ind == stop)
  2217.             return start;
  2218.       }
  2219.      }
  2220.      return NULL;
  2221. }
  2222.  
  2223. /*
  2224.  * Safe and sane strcmp. Deals with null pointer for either arg and ignores
  2225.  * case. All whitespace is considered equivalent.
  2226.  */
  2227. Local Inline int strcomp(s1, s2)
  2228. register String s1, s2;
  2229. {
  2230.      if (s1 && s2) {
  2231.       if (strlen(s1) != strlen(s2))
  2232.            return -1;
  2233.       
  2234.       while (*s1 && *s2 && (TOLOWER(*s1) == TOLOWER(*s2)))
  2235.            ++s1, ++s2;
  2236.       if (!*s1 && !*s2)
  2237.            return 0;
  2238.       else if (*s1 < *s2)
  2239.            return -1;
  2240.       else
  2241.            return 1;
  2242.      }
  2243.      else if (!s1 && !s2)
  2244.           return 0;
  2245.      else if (!s1 && s2)
  2246.           return -1;
  2247.      else
  2248.           return 1;
  2249. }
  2250.  
  2251. /* like above, but stops after n characters */
  2252. Local Inline int strncomp(s1, s2, n)
  2253. register String s1, s2;
  2254. int n;
  2255. {
  2256.      register String s3 = s2 + n;
  2257.      
  2258.      if (s1 && s2) {
  2259.       while (s2 < s3 && *s1 && *s2 && (TOLOWER(*s1) == TOLOWER(*s2)))
  2260.            ++s1, ++s2;
  2261.       if (!*s1 && !*s2 || s2 == s3)
  2262.            return 0;
  2263.       else if (*s1 < *s2)
  2264.            return -1;
  2265.       else
  2266.            return 1;
  2267.      }
  2268.      else if (!s1 && !s2)
  2269.           return 0;
  2270.      else if (!s1 && s2)
  2271.           return -1;
  2272.      else
  2273.           return 1;
  2274. }
  2275.  
  2276. /* Copy s2 to s1 up to (but not including) character c */
  2277. Local Inline void strccpy(s1, s2, c)
  2278. register String s1, s2;
  2279. register char c;
  2280. {
  2281.      while (*s2 && *s2 != c)
  2282.       *(s1++) = *(s2++);
  2283.      *s1 = '\0';
  2284. }
  2285.  
  2286. /*
  2287.  * Return integer subscript of character 'c' in string 's'.
  2288.  * (why doesn't this already exist in a library somewhere?).
  2289.  */
  2290. Local Inline int iindex(s, c)
  2291. register char *s, c;
  2292. {
  2293.      register char *cp;
  2294.      
  2295.      if (!s)
  2296.           return -1;
  2297.      cp = index(s, c);
  2298.      if (cp)
  2299.           return cp - s;
  2300.      else
  2301.           return -1;
  2302. }
  2303.  
  2304. Local String substr(s, p1, p2)
  2305. register String s;
  2306. register int p1, p2;
  2307. {
  2308.      Local char ret[MAXSTR];
  2309.      register int i = 0;
  2310.      
  2311.      if (p1 > p2) {
  2312.       sprintf(ret, "substr: start %d, end %d. start must be <= end",
  2313.           p1, p2);
  2314.       XtWarning(ret);
  2315.           return NULL;
  2316.      }
  2317.      if (p2 - p1 > MAXSTR) {
  2318.           sprintf(ret, "substr: end - start is > max len of %d", MAXSTR);
  2319.       XtWarning(ret);
  2320.           return NULL;
  2321.      }
  2322.      while (p1 <= p2)
  2323.           ret[i++] = s[p1++];
  2324.      ret[i] = '\0';
  2325.      return ret;
  2326. }
  2327.  
  2328. /*
  2329.  * Safely concatenate two strings into static area, returning pointer to
  2330.  * result.
  2331.  */
  2332. Local String strconcat(s1, s2)
  2333. register String s1, s2;
  2334. {
  2335.      Local char ret[MAXSTR];
  2336.      int len1;
  2337.      
  2338.      if (s1) {
  2339.       if ((len1 = strlen(s1)) >= MAXSTR) {
  2340.            sprintf(ret, "strconcat: length of s1 > MAX (%d)", MAXSTR);
  2341.            XtWarning(ret);
  2342.            return NULL;
  2343.       }
  2344.       else
  2345.            strcpy(ret, s1);
  2346.       if (s2) {
  2347.            if (len1 + strlen(s2) > MAXSTR) {
  2348.             sprintf(ret, "strconcat: length of s1 + s2 is > MAX (%d)",
  2349.                 MAXSTR);
  2350.             XtWarning(ret);
  2351.            }
  2352.            else
  2353.             strcat(ret, s2);
  2354.       }
  2355.       return ret;
  2356.      }
  2357.      else
  2358.       return NULL;
  2359. }
  2360.  
  2361. /* reverse a string so that a simple reverse search may be done on it */
  2362. Local String reverse(s)
  2363. register String s;
  2364. {
  2365.      Local char ret[MAXSTR];
  2366.      register int i, len;
  2367.      
  2368.      if ((len = strlen(s)) > MAXSTR) {
  2369.       sprintf(ret, "reverse: string too long to reverse. MAX is %d",
  2370.           MAXSTR);
  2371.       XtWarning(ret);
  2372.       return NULL;
  2373.      }
  2374.      else {
  2375.       i = 0;
  2376.       while (len)
  2377.            ret[i++] = s[--len];
  2378.       ret[i] = '\0';
  2379.       return ret;
  2380.      }
  2381. }
  2382.  
  2383. /* convert a string to lower case */
  2384. Local Inline String downcase(s)
  2385. register String s;
  2386. {
  2387.      String orig = s;
  2388.      
  2389.      if (s)
  2390.       while (*s) {
  2391.            *s = TOLOWER(*s);
  2392.            s++;
  2393.       }
  2394.      return orig;
  2395. }
  2396.  
  2397. #ifdef BSD
  2398. /* BSD users don't have strpbrk() */
  2399. /* Routines borrowed from PD libc written by Richard A. O'Keefe. */
  2400.  
  2401. #if     CharsAreSigned
  2402. #define MaxPosChar      127
  2403. #else  ~CharsAreSigned
  2404. #define MaxPosChar      255
  2405. #endif  CharsAreSigned
  2406. #ifndef _AlphabetSize
  2407. #define _AlphabetSize   128
  2408. #endif
  2409.  
  2410. static int  _set_ctr = MaxPosChar;
  2411. static char _set_vec[_AlphabetSize];
  2412.  
  2413. void _str2set(set)
  2414. register String set;
  2415. {
  2416.      if (set == NULL)
  2417.       return;
  2418.      if (++_set_ctr == MaxPosChar+1) {
  2419.       register char *w = &_set_vec[_AlphabetSize];
  2420.       do
  2421.            *--w = '\0';
  2422.       while (w != &_set_vec[0]);
  2423.           _set_ctr = 1;
  2424.      }
  2425.      while (*set)
  2426.       _set_vec[*set++] = _set_ctr;
  2427. }
  2428.  
  2429. String strpbrk(s1, s2)
  2430. register String s1, s2;
  2431. {
  2432.      _str2set(set);
  2433.      while (_set_vec[*str] != _set_ctr)
  2434.           if (!*str++)
  2435.            return NULL;
  2436.      return str;
  2437. }
  2438. #endif /* BSD */
  2439.